Adya
Uber blew its entire 2026 AI coding budget in four months. Microsoft started pulling internal AI coding licenses. Read those two facts together and you get the quiet story of enterprise AI this year: the tools work, and that is exactly the problem.
Let me be fair to the first half of that. The productivity is real. Engineers ship faster. Work that took a day takes an hour. For anyone who has watched a stuck team start shipping, these are not hype.
But here is the part nobody priced in. When a tool makes your team more productive, your team uses it more. Every productive hour burns more tokens than the hour before it. So your bill does not track your revenue. It tracks your usage, and usage tracks success.
That is the trap. Productivity that scales your cost faster than your value is not a gain. It is a subscription to your own success. After the crossover, every productive hour costs more than it returns. That gap is pure tax.
Economists named this more than 150 years ago. In 1865, William Jevons noticed that as steam engines got more efficient, Britain burned more coal, not less, because efficiency made coal worth using for everything. It happened again with electricity, and with bandwidth. It is happening now with tokens.
Make each call cheaper and total spend goes up, not down, because cheaper makes the tool worth using for everything. The trap is not a quirk of your vendor’s price list. It is a law, and it is showing up in your cloud bill.
Section 01Why the bill grows faster than the work
There is a mechanical reason this happens, and it is worth understanding, because it tells you exactly where the fix has to live.
Most agentic systems today are stateless. To make an agent “remember” anything, you pass the entire history back into the model on every single call. Ten turns in, you are re-sending the first nine, every time. The context keeps growing and the token cost grows with it: not linearly, closer to quadratically. The agent does more, so it carries more context, so each step costs more. The curve bends up at precisely the moment the agent becomes useful.
Now add the operational reality on top. A container restarts and the agent’s context is gone, so it reloads everything. Orchestration falls over, so work gets retried. Every one of those failures is paid for in tokens. If you have ever watched an agent reload its whole context after a 2 a.m. restart and silently re-run an hour of work, you have already paid this tax. You just saw it as a line item, not as a design choice.
You did not buy a greedy model and watch the bill climb. You bought a stateless architecture, and you are paying the tax on it.
Section 02A usage cap is the wrong fix
The obvious response is to cap it. Set budgets. Ration seats. Pull licenses, the way Microsoft just did. That treats the symptom and kills the upside. A cap says: be less productive, so we can afford you. You have now turned your most valuable tool into the thing your team is nervous to open.
The wrong fix
- Asks your team to be less productive so you can afford them
- Turns your best tool into the thing people fear opening
- A tax on your own momentum, not cost control
The real fix
- Record each agent action once, recall it as needed
- Keep the causality without dragging the whole history through the model
- Cut cost by doing the same work, not less of it
If the cost comes from re-sending context and re-doing dropped work, you fix it by changing how the system holds memory and state. Not by telling people to use it less. This is the whole reason we built Event-Sourced Memory into the platform.
Record once. Recall as needed.
Instead of replaying the full transcript on every call, each agent action is recorded once and recalled when it is needed. The agent keeps its causality without dragging the entire history through the model at every step.
The model is rented. The architecture is yours.
Cost is not a thing that happens to you from a vendor’s price list. It is a thing you design for, or fail to. In our own systems, holding state once cut token cost by roughly 70 percent on long-horizon work — not by doing less.
The model is rented, but the architecture is yours. Cost is not a thing that happens to you. It is a thing you design for, or fail to.
Section 03The model is the froth. The architecture is the value.
Step back and the pattern is bigger than one budget line. There is a lot of noise right now about an AI bubble, about whether enterprise AI returns enough to justify the spend. Most of that froth sits in the model layer, where prices, rankings, and this quarter’s winner change every quarter.
The durable value sits one layer down, in the unglamorous infrastructure that survives whichever model wins: how you hold memory, how you govern what agents are allowed to do, how you swap one model for another without re-architecting everything around it. The harness, not the engine.
A company that owns that layer treats the model as a swappable component. A cheaper or better one arrives, they switch in an afternoon, and their cost curve bends down. A company that rents the whole stack from a single vendor watches the bill rise with its own success and calls it the price of progress. One of those companies is compounding. The other is funding theater.
If the model is the part you rent, the sharper question is when you stop renting it at all: a smaller model, tuned to your own domain, that you own outright, that no vendor can switch off or reprice overnight. Most of the time, swappable is enough. Sometimes it is not, and building your own is the right move — and a dangerous one to get wrong. That is a different newsletter, and it is coming next.
Section 04What this means for you
If your AI spend is climbing faster than the value you pull from it, do not reach for the cap. The bill is a symptom. The disease is an architecture that pays a tax on every useful hour and forgets everything the moment a container restarts. Four moves change that.
Own the layer where cost lives
Cost is not handed to you by a price list. It is decided by how your system holds memory and state. That layer is yours to design, so design it.
Hold state once
Record each action once and recall it as needed, instead of re-sending the whole transcript on every call. The cost curve stops bending up at the moment the agent gets useful.
Govern what gets re-run
A restart that reloads everything and a dropped task that silently retries are both paid for in tokens. Control the re-runs so failures are not quietly billed to you.
Keep the model swappable
The day a cheaper or better model ships, you benefit instead of renegotiating. Run on any model and change the engine underneath in an afternoon, with no loss to the apps on top.
Do that, and productivity finally does what it promised: your value climbs while your unit cost falls. That is the difference between renting your own success and owning it.
Own the layer where cost and control actually live. That is the difference between renting your own success and owning it.
Get the next one in your inbox
This newsletter cuts past the AI hype to the architecture underneath: what compounds versus what just trends. No demos, no pitch, just a clearer way to think about enterprise AI, every week.
Start building on Vanij